// Once elasticsearch bundle is downloaded
$cd {downloaded elasticsearch server location}
$cd bin
$./elasticsearch

# Name of the cluster. This should match the name of the cluster in 
# {elastic search server location}/elasticsearch-1.2.1/config/elasticsearch.yml file
# Note that the cluster name have to be set if different than "elasticsearch"
# ex: elasticsearch.clusterName=myelasticsearch

# Address of at least one Elasticsearch node in the cluster. 
# The plugin will get from that node the rest of the nodes in the cluster, and use all of those when round robin requests. 
 elasticsearch.node={comma separated node list with port numbers}
# ex: elasticsearch.node=192.168.1.4:9300

# Location of the elasticsearch server in the file system
 elasticsearch.homeFile={path to elasticsearch server}/elasticsearch-1.2.1
# ex: elasticsearch.homeFile=/folder/subfolder/server/elasticsearch-1.2.1

#
# Elasticsearch Web Plugin properties
#

#These entry classnames will be excluded from indexing
indexExcludedType=com.liferay.portal.kernel.plugin.PluginPackage,com.liferay.portal.kernel.lar.ExportImportHelper

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
	id="WebApp_ID" version="2.5">
	<context-param>
		<param-name>portalContextConfigLocation</param-name>
		<param-value>/WEB-INF/classes/META-INF/elasticsearch-spring.xml</param-value>
	</context-param>
	<listener>
		<listener-class>com.liferay.portal.kernel.spring.context.PortletContextLoaderListener</listener-class>
	</listener>
</web-app>

<?xml version="1.0"?>
<beans default-destroy-method="destroy" default-init-method="afterPropertiesSet" xmlns="http://www.springframework.org/schema/beans" xmlns:util="http://www.springframework.org/schema/util"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.0.xsd">
    <bean class="com.liferay.portal.spring.context.PortletBeanFactoryPostProcessor" />
    <!-- Search -->
    <bean id="queryBuilder" class="com.rivetlogic.portal.search.elasticsearch.querybuilder.ElasticsearchQueryBuilder" />
    <bean id="searchHelper" class="com.rivetlogic.portal.search.elasticsearch.util.ElasticsearchHelper">
        <property name="esConnector" ref="elasticsearchConnector" />    
        <property name="esQueryBuilder" ref="queryBuilder" />
    </bean>
    <bean id="indexSearcher.elasticsearch" class="com.rivetlogic.portal.search.elasticsearch.ElasticsearchIndexSearcherImpl">
        <property name="esSearchHelper" ref="searchHelper" />
    </bean>
    <!-- Indexer -->
    <bean id="elasticsearchDocumentJSONBuilder" class="com.rivetlogic.portal.search.elasticsearch.indexer.document.ElasticsearchDocumentJSONBuilder" init-method="loadExcludedTypes" />
    <bean id="elasticsearchConnector" class="com.rivetlogic.portal.search.elasticsearch.util.ElasticsearchConnector" init-method="initESSetup" destroy-method="close" />
    <bean id="elasticsearchIndexer" class="com.rivetlogic.portal.search.elasticsearch.indexer.ElasticsearchIndexerImpl">
        <property name="documentJSONBuilder" ref="elasticsearchDocumentJSONBuilder" />
    </bean>
    <bean id="indexWriter.elasticsearch" class="com.rivetlogic.portal.search.elasticsearch.ElasticsearchIndexWriterImpl">
        <property name="indexer" ref="elasticsearchIndexer" />
        <property name="esConnector" ref="elasticsearchConnector" />
    </bean>
    <!-- Search Engine -->
    <bean id="searchEngine.elasticsearch" class="com.liferay.portal.kernel.search.BaseSearchEngine">
        <property name="clusteredWrite" value="false" />
        <property name="indexSearcher" ref="indexSearcher.elasticsearch" />
        <property name="indexWriter" ref="indexWriter.elasticsearch" />
        <property name="luceneBased" value="true" />
        <property name="vendor" value="ELASTICSEARCH" />
    </bean>
    <!-- Configurator -->
    <bean id="searchEngineConfigurator.elasticsearch" class="com.liferay.portal.kernel.search.PluginSearchEngineConfigurator">
		<property name="searchEngines">
			<util:map>
				<entry key="SYSTEM_ENGINE" value-ref="searchEngine.elasticsearch" />
			</util:map>
		</property>        
    </bean>
    <!-- ===== MESSAGING ===== -->
    <!-- Message source -->
    <bean id="messageSender.elasticsearch_plugin" class="com.rivetlogic.portal.messaging.sender.PluginMessageSender" />
    <bean id="messageListener.bridging.elasticsearch" class="com.liferay.portal.kernel.messaging.BridgingMessageListener">
        <property name="singleDestinationMessageSender">
            <bean class="com.liferay.portal.kernel.messaging.sender.DefaultSingleDestinationMessageSender">
                <property name="destinationName" value="liferay/search_writer/ELASTICSEARCH" />
                <property name="messageSender" ref="messageSender.elasticsearch_plugin" />
            </bean>
        </property>
    </bean>
    <!-- Listeners -->
    <bean id="messageListener.elasticsearch_reader" class="com.liferay.portal.kernel.search.messaging.SearchReaderMessageListener">
        <property name="searchEngine" ref="searchEngine.elasticsearch" />
    </bean>
    <bean id="messageListener.elasticsearch_writer" class="com.liferay.portal.kernel.search.messaging.SearchWriterMessageListener">
        <property name="searchEngine" ref="searchEngine.elasticsearch" />
    </bean>
    <!-- Destinations -->
    <bean id="destination.elasticsearch_searcher" class="com.liferay.portal.kernel.messaging.ParallelDestination">
        <constructor-arg index="0" type="java.lang.String" value="liferay/search_reader/ELASTICSEARCH" />
    </bean>
    <bean id="destination.elasticsearch_writer" class="com.liferay.portal.kernel.messaging.ParallelDestination">
        <constructor-arg index="0" type="java.lang.String" value="liferay/search_writer/ELASTICSEARCH" />
    </bean>
    <!-- Routing -->
    <bean id="messagingConfigurator.elasticsearch" class="com.liferay.portal.kernel.messaging.config.PluginMessagingConfigurator" depends-on="searchEngine.elasticsearch">
        <property name="destinations">
            <list>
            	<ref bean="destination.elasticsearch_searcher" />
                <ref bean="destination.elasticsearch_writer" />
            </list>
        </property>
        <property name="messageListeners">
            <map key-type="java.lang.String" value-type="java.util.List">
                <entry key="liferay/search_reader/ELASTICSEARCH">
                    <list value-type="com.liferay.portal.kernel.messaging.MessageListener">
                        <ref bean="messageListener.elasticsearch_reader" />
                    </list>
                </entry>
                <entry key="liferay/search_writer/SYSTEM_ENGINE">
                    <list value-type="com.liferay.portal.kernel.messaging.MessageListener">
                        <ref bean="messageListener.bridging.elasticsearch" />
                    </list>
                </entry>
                <entry key="liferay/search_writer/ELASTICSEARCH">
                    <list value-type="com.liferay.portal.kernel.messaging.MessageListener">
                        <ref bean="messageListener.elasticsearch_writer" />
                    </list>
                </entry>
            </map>
        </property>
    </bean>
</beans>

#
# Autosuggestion related properties
#


# A comma separated list of Fields to be queried to obtain Autosuggestions for search phrase with respective boost value
# Different weights can be assigned to matches at different positions allowing for things like phrase matches 
# being sorted above term matches when highlighting a Boosting Query that boosts phrase matches over term matches
# Format: fieldName^boostValue OR fieldName
# Ex: title^10,lastName,screenName
 suggestionQueryFields=title^10,userName^8,author^9,content^3,firstName^8,lastName,screenName

# Comma separated list of Liferay objects/Elasticsearch index types to be excluded from 
# autosuggestion query
# A liferay object maps to a corresponding Elasticsearch index type, so the objects can be
# added here to be excluded
 suggestionQueryExcludedType=com.liferay.portal.model.Contact

# Optional: Number of suggestions to be displayed when a user is typing in search portlet, 
# if not specified defaults to 4
# ex: autoSuggestionsSize=6

# Optional: The suggestion query size parameter allows to configure the maximum amount of hits to be returned from its query.
# if not specified defaults to 10 which is the default query size in Elasticsearch
# ex: autoSuggestionsQueryMaxHits=15

# Optional: Length of the text to be displayed as a suggestion,
# if not specified defaults to 50
# ex:autoSuggestionLength=80

public class ElasticsearchConnector {
	private String propsFile;
	private Client = null;
	private Properties prop;
 
	public Properties getProps() {
		return prop;
	}
 
	public void setPropsFile(String propsFile) {
		this.propsFile = propsFile;
	}
 
	public void initESSetup() {
		// initializer of elasticsearch connection
 
		// load node list from "elastic.props" properties file
 
		// establish transport client for each node
 
		// client object created is used by index writer/searcher
	}
 
	public void close() {
		...
		client.close();
		...
	}
 
	public Client getClient() {
		return client;
	}
 
	private boolean isLiferayIndexExists() {
		// checks if "liferay" index exists in elasticsearch server
	}
 
	private void createliferayIndexInESServer() {
		// create a mapping aliases for different field types
		// field type is used when queries are executed against elasticsearch
		// based on the type, elasticsearch tries to convert the data from response to correct type
		// which uses the alias to overcome wrong type related exceptions
	}
}

public class ElasticsearchJSONDocument {
	private String id;
	private String indexType;
	private String jsonDocument;
	private String errorMessage;
	private boolean isError;
 
	public enum DocumentError {
		HIDDEN_DOCUMENT, MISSING_CLASSPK, MISSING_ENTRYCLASSNAME, EXCLUEDED_TYPE;
		private String errorMsg;
		private DocumentError(String value) {
			this.errorMsg = value;
		}
		public String toString() {
			return errorMsg;
		}
	};
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getIndexType() {
        return indexType;
    }
    public void setIndexType(String indexType) {
        this.indexType = indexType;
    }
    public String getJsonDocument() {
        return jsonDocument;
    }
    public void setJsonDocument(String jsonDocument) {
        this.jsonDocument = jsonDocument;
    }
    public String getErrorMessage() {
        return errorMessage;
    }
    public void setErrorMessage(String errorMessage) {
        this.errorMessage = errorMessage;
    }
    public boolean isError() {
        return isError;
    }
    public void setError(boolean isError) {
        this.isError = isError;
    }
} 

public class ElasticsearchDocumentJSONBuilder {
	private Set<String> excludedTypes;
	private ElasticsearchConnector _esConnector;
 
	public void setEsConnector(ElasticsearchConnector esConnector) {
		this._esConnector = esConnector;
	}
 
	public void loadExcludedTypes() {
		// load excluded types from elastic.props properties file
	}
 
	public ElasticesearchJSONDocument convertToJSON(final Document document) {
		// converts the elements of document object into JSON form
 
		// filters out some special cases like hidden folders, empty entryClassName case and excluded type of entryClassName cases
	}
 
	private boolean isDocumentHidden(Document document) {
		// checks if the document object is hidden object in Liferay
	}
 
	private boolean isExcludedType(String indexType) {
		// checks if the document object is of excluded class types
	}
}

public class ElasticsearchIndexerImpl implements ElasticsearchIndexer {
	private ElasticsearchDocumentJSONBuilder documentJSONBuilder;
	
	public void setDocumentJSONBuilder(ElasticsearchDocumentJSONBuilder documentJSONBuilder) {
		return documentJSONBuilder;
	}
	public Collection<ElasticserachJSONDocument> processDocuments(Collection<Document> documents) throws ElasticsearchIndexingException {
		// process multiple documents as bulk
    }

    public ElasticserachJSONDocument processDocument(Document document) throws ElasticsearchIndexingException {
		// process a single document object
    }
} 

public class ElasticsearchIndexerWriterImpl extends BaseIndexWriter {
	private ElasticsearchIndexer _indexer;
	private ElasticsearchConnector _esConnector;
 
	public void setEsConnector(ElasticsearchConnector esConnector) {
        this._esConnector = esConnector;
    }
 
    public void setIndexer(ElasticsearchIndexer indexer) {
        this._indexer = indexer;
    }
 
	public void addDocument(SearchContext searchContext, Document document) throws SearchException {
		// add a new document to elasticsearch index
	}
 
	public void deleteDocument(SearchContext searchContext, String uid) throws SearchException {
		// invoke delete index process using the uid
	}
 
	public void updateDocument(SearchContext searchContext, Document document) throws SearchException {
		// invoke update index process
		// update will overwrite current existing index using the same UID passed in from the document object
	}
} 

public class ElasticsearchIndexSearcherImpl extends BaseIndexSearcher {
	private ElasticsearchHelper _esSearchHelper;
 
	public ElasticsearchHelper getEsSearchHelper() {
		return _esSearchHelper;
	}
	public void setEsSearchHelper(ElasticsearchHelper esSearchHelper) {
		this._esSearchHelper = esSearchHelper;
	}

    @Override
    public Hits search(SearchContext searchContext, Query query) throws SearchException {
		// invoke search process from ElasticsearchHelper class
    }
} 

public class ElasticsearchHelper {
	private ElasticsearchConnector _esConnector;
	private ElasticsearchQueryBuilder _esQueryBuilder;
	
	public ElasticsearchConnector getEsConnector() {
        return _esConnector;
    }
	public void setEsConnector(ElasticsearchConnector esConnector) {
        this._esConnector = esConnector;
    }
	public ElasticsearchQueryBuilder getEsQueryBuilder() {
        return _esQueryBuilder;
    }
	public void setEsQueryBuilder(ElasticsearchQueryBuilder esQueryBuilder) {
        this._esQueryBuilder = esQueryBuilder;
    }
 
	public Hits getSearchHits(SearchContext searchContext, Query query) {
		// get client from the connector object
		// create SearchRequestBuilder which loads query built from _esQueryBuilder
		// executes the query against elasticsearch and gets SearchHits from the response
		// set up documents and other related information to hits which Liferay will use to render the search results
	}
 
	private SortBuilder getSort(SearchContext searchContext) {
		// set up SortBuilder from sort information in SearchContext
	}
	
	private Float[] getScores(SearchHits searchHits) {
		// get scores from searchHits to update Hits object for Liferay to use
	}
 
	private Document[] getDocuments(SearchHits searchHits) {
		// get results from searchHits in JSON form
		// transform JSON objects into Document objects so Liferay can use
	}
 
	private Map<String, Integer> parseESFacet(Facet esFacet) {
		// returns a map of facets and their counts
	}
 
	private void handleFacetQueries(SearchContext searchContext, SearchRequestBuilder searchRequestBuilder) {
		// compares request facets from Liferay against facets returned from elasticsearch
		// and updates the facets for the search results with the latest facet information including the updated counts
	}
 
	private void collectFacetResults(SearchContext searchContext, SearchResponse response) {
		// collect facets from the search response
		// and transform them into Liferay's facet form so Liferay can use them to render the facets properly
	}
 
	private String buildRangeTerm(Entry entry) {
		// build range query for elasticsearch use for range facet
	}
 
	private Set<String> facetEntryClassnames(Facet liferayFacet) {
		// fetch entry classnames
	}
 
	private String[] fetchFromToValuesInRange(JSONObject jsonObject) {
		// fetch from to values in range
	}
} 

public class ElasticsearchQueryBuilder{
	public QueryStringQueryBuilder doSearch(Query query) {
		return QueryBuilders.queryString(query.toString());
	}
} 
 

public class ElasticsearchDeaultTermCollector implements TermCollector {
	private String term;
	private int frequency;
 
	public ElasticsearchDefaultTermCollector(String term, int frequency) {
		this.term = term;
		this.frequency = frequency;
	}	
 
	public String getTerm() {
		return this.term;
	}
 
	public int getFrenquency() {
		return this.frequency;
	}
}

 public class ElasticsearchQueryFacetCollector implements FacetCollector {
	private Map<String, Integer> _counts = new HashMap<String, Integer>();
	private String _fieldName;
	private List<TermCollector> _termCollectors;
 
	public ElasticsearchQueryFacetCollector(String feildName, Map<String, Integer> facetResults) {
		// update fieldName and its count
	}
 
	public String getFieldName() {
		return this.fieldName;
	}
 
	public TermCollector getTermCollector(String term) {
		// returns a new ElasticsearchDefaultTermCollector with the term and its count
	}
 
	public List<TermCollector> getTermCollectors() {
		// return a list of termCollectors
	}
}

public class ElasticsearchPortlet extends MVCPortlet {
    /*
     * (non-Javadoc)
     * 
     * @see javax.portlet.GenericPortlet#init(javax.portlet.PortletConfig)
     */
    @Override
    public void init(PortletConfig portletConfig) {
        super.init(portletConfig);
		.....
    }
    /*
     * (non-Javadoc)
     * 
     * @see javax.portlet.GenericPortlet#destroy()
     */
    @Override
    public void destroy() {
        super.destroy();
        .....
    }
    /*
     * (non-Javadoc)
     * 
     * @see com.liferay.util.bridges.mvc.MVCPortlet#serveResource(javax.portlet.
     * ResourceRequest, javax.portlet.ResourceResponse)
     */
    @Override
    public void serveResource(ResourceRequest resourceRequest, ResourceResponse resourceResponse) {
		//Get the suggestions using PortletHelper class
    }
}

public class ElasticsearchPortletHelper {
    /**
     * Creates a transport client to interact with Elasticsearch servers.
     */
    public void createClient() {
		//Initiates a transport client
    }
    /**
     * A method to closes client properly to avoid memory leaks.
     */
    public void destroyClient() {
    }
    /**
     * Fetch auto suggestions.
     *
     * @param resourceRequest the resource request
     * @param resourceResponse the resource response
     * @throws IOException Signals that an I/O exception has occurred.
     * @throws ElasticsearchAutocompleteException the elasticsearch autocomplete exception
     */
    public void fetchAutoSuggestions(ResourceRequest resourceRequest, ResourceResponse resourceResponse)
            throws IOException, ElasticsearchAutocompleteException {
        PrintWriter out = resourceResponse.getWriter();
        out.println(parseResponse(response));
    }
    /**
     * Creates the Elasticsearch request builder with all necessary settings.
     */
    private void createESRequestBuilder() {
    }
    /**
     * Gets the transport hosts.
     *
     * @return the transport hosts
     */
    private InetSocketTransportAddress[] getTransportHosts() {
        return transportAddresses;
    }
    /**
     * Append query fields to builder.
     *
     * @param builder the builder
     */
    private void appendQueryFieldsToBuilder(QueryStringQueryBuilder builder) {
    }
    /**
     * Parses the response.
     *
     * @param response the response
     * @return the string
     */
    private String parseResponse(SearchResponse response) {
		//return the formatted suggestions
        return arraySuggestions.toString();
    }
}

public class ElasticsearchPropsValues {
    /**
     * Gets the property.
     * 
     * @param key
     *            the key
     * @return the property
     */
    public String getProperty(String key) {
        return props.getProperty(key);
    }
    /**
     * Gets the property.
     * 
     * @param key
     *            the key
     * @param defaultValue
     *            the default value
     * @return the property
     */
    public int getProperty(String key, int defaultValue) {
        return GetterUtil.getInteger(getProperty(key), defaultValue);
    }
    /**
     * Gets the suggestions size.
     * 
     * @return the suggestions size
     */
    public int getSuggestionsSize() {
        return suggestionsSize;
    }
    /**
     * Gets the suggestions length.
     * 
     * @return the suggestions length
     */
    public int getSuggestionsLength() {
        return suggestionsLength;
    }
    /**
     * Gets the es server home.
     * 
     * @return the es server home
     */
    public String getEsServerHome() {
        return esServerHome;
    }
    /**
     * Gets the suggestion query fields.
     * 
     * @return the suggestion query fields
     */
    public Map<String, Float> getSuggestionQueryFields() {
        return suggestionQueryFields;
    }
    /**
     * Gets the suggestion excluded types.
     * 
     * @return the suggestion excluded types
     */
    public Set<String> getSuggestionExcludedTypes() {
        return suggestionExcludedTypes;
    }
    
    ............
}

<?xml version="1.0"?>
<!DOCTYPE hook PUBLIC "-//Liferay//DTD Hook 6.2.0//EN" "http://www.liferay.com/dtd/liferay-hook_6_2_0.dtd">
<hook>
    <portal-properties>content/portal.properties</portal-properties>
	<custom-jsp-dir>/META-INF/custom_jsps</custom-jsp-dir>
</hook>