package com.self_learn.constants; /** * Specifies the type of BulkRequest * * @author harikrishna_gurram */ public enum BulkRequestType { INDEX, UPDATE, UPSERT_UPDATE, DELETE }
package com.self_learn.model; import lombok.EqualsAndHashCode; import lombok.Getter; import lombok.Setter; import lombok.ToString; import com.self_learn.constants.BulkRequestType; @EqualsAndHashCode() @ToString public class BulkObject { @Getter @Setter private String _index; @Getter @Setter private String _type; @Getter @Setter private String _id; @Getter @Setter private String _source; @Getter @Setter private String _upsertSource; @Getter @Setter private BulkRequestType type; public BulkObject(String _index, String _type, String _id, BulkRequestType type) { this._index = _index; this._type = _type; this._id = _id; this.type = type; } public BulkObject(String _index, String _type, String _id, BulkRequestType type, String _source) { this(_index, _type, _id, type); this._source = _source; } public BulkObject(String _index, String _type, String _id, BulkRequestType type, String _source, String _upsertSource) { this(_index, _type, _id, type, _source); this._upsertSource = _upsertSource; } }
package com.self_learn.util; import java.util.Set; import org.elasticsearch.action.bulk.BulkRequestBuilder; import org.elasticsearch.action.bulk.BulkResponse; import org.elasticsearch.action.delete.DeleteRequest; import org.elasticsearch.action.index.IndexRequest; import org.elasticsearch.action.update.UpdateRequest; import org.elasticsearch.client.Client; import org.elasticsearch.common.base.Preconditions; import org.elasticsearch.common.lang3.StringUtils; import com.self_learn.constants.BulkRequestType; import com.self_learn.model.BulkObject; /** * Utility class to execute bulk requests. * * @author harikrishna_gurram */ public class BulkUtil { private static BulkObject getBulkObject(String _index, String _type, String _id, BulkRequestType type) { return new BulkObject(_index, _type, _id, type); } private static BulkObject getBulkObject(String _index, String _type, String _id, BulkRequestType type, String _source) { return new BulkObject(_index, _type, _id, type, _source); } private static BulkObject getBulkObject(String _index, String _type, String _id, BulkRequestType type, String _source, String _upsertSource) { return new BulkObject(_index, _type, _id, type, _source, _upsertSource); } public static BulkObject getIndexObject(String _index, String _type, String _id, String _source) { Preconditions.checkNotNull(_index, "_index shouldn't be null"); Preconditions.checkNotNull(_type, "_type shouldn't be null"); Preconditions.checkNotNull(_id, "_id shouldn't be null"); Preconditions.checkNotNull(_source, "_source shouldn't be null"); Preconditions.checkState((!StringUtils.isEmpty(_index)), "_index should not be empty"); Preconditions.checkState((!StringUtils.isEmpty(_type)), "_type should not be empty"); Preconditions.checkState((!StringUtils.isEmpty(_id)), "_id should not be empty"); return getBulkObject(_index, _type, _id, BulkRequestType.INDEX, _source); } public static BulkObject getDeleteObject(String _index, String _type, String _id) { Preconditions.checkNotNull(_index, "_index shouldn't be null"); Preconditions.checkNotNull(_type, "_type shouldn't be null"); Preconditions.checkNotNull(_id, "_id shouldn't be null"); Preconditions.checkState((!StringUtils.isEmpty(_index)), "_index should not be empty"); Preconditions.checkState((!StringUtils.isEmpty(_type)), "_type should not be empty"); Preconditions.checkState((!StringUtils.isEmpty(_id)), "_id should not be empty"); return getBulkObject(_index, _type, _id, BulkRequestType.DELETE); } public static BulkObject getUpdateObject(String _index, String _type, String _id, String _source) { Preconditions.checkNotNull(_index, "_index shouldn't be null"); Preconditions.checkNotNull(_type, "_type shouldn't be null"); Preconditions.checkNotNull(_id, "_id shouldn't be null"); Preconditions.checkNotNull(_source, "_source shouldn't be null"); Preconditions.checkState((!StringUtils.isEmpty(_index)), "_index should not be empty"); Preconditions.checkState((!StringUtils.isEmpty(_type)), "_type should not be empty"); Preconditions.checkState((!StringUtils.isEmpty(_id)), "_id should not be empty"); return getBulkObject(_index, _type, _id, BulkRequestType.UPDATE, _source); } public static BulkObject getUpsertUpdateObject(String _index, String _type, String _id, String _source, String _upsertSource) { Preconditions.checkNotNull(_index, "_index shouldn't be null"); Preconditions.checkNotNull(_type, "_type shouldn't be null"); Preconditions.checkNotNull(_id, "_id shouldn't be null"); Preconditions.checkNotNull(_source, "_source shouldn't be null"); Preconditions.checkNotNull(_upsertSource, "_upsertSource shouldn't be null"); Preconditions.checkState((!StringUtils.isEmpty(_index)), "_index should not be empty"); Preconditions.checkState((!StringUtils.isEmpty(_type)), "_type should not be empty"); Preconditions.checkState((!StringUtils.isEmpty(_id)), "_id should not be empty"); return getBulkObject(_index, _type, _id, BulkRequestType.UPSERT_UPDATE, _source, _upsertSource); } public static BulkObject getIndexObject(String _index, String _type, String _id, Object _source) { Preconditions.checkNotNull(_index, "_index shouldn't be null"); Preconditions.checkNotNull(_type, "_type shouldn't be null"); Preconditions.checkNotNull(_id, "_id shouldn't be null"); Preconditions.checkNotNull(_source, "_source shouldn't be null"); Preconditions.checkState((!StringUtils.isEmpty(_index)), "_index should not be empty"); Preconditions.checkState((!StringUtils.isEmpty(_type)), "_type should not be empty"); Preconditions.checkState((!StringUtils.isEmpty(_id)), "_id should not be empty"); return getIndexObject(_index, _type, _id, JSONUtil.getJson(_source)); } public static BulkObject getUpdateObject(String _index, String _type, String _id, Object _source) { Preconditions.checkNotNull(_index, "_index shouldn't be null"); Preconditions.checkNotNull(_type, "_type shouldn't be null"); Preconditions.checkNotNull(_id, "_id shouldn't be null"); Preconditions.checkNotNull(_source, "_source shouldn't be null"); Preconditions.checkState((!StringUtils.isEmpty(_index)), "_index should not be empty"); Preconditions.checkState((!StringUtils.isEmpty(_type)), "_type should not be empty"); Preconditions.checkState((!StringUtils.isEmpty(_id)), "_id should not be empty"); return getUpdateObject(_index, _type, _id, JSONUtil.getJson(_source)); } public static BulkObject getUpsertUpdateObject(String _index, String _type, String _id, Object _source, Object _upsertSource) { Preconditions.checkNotNull(_index, "_index shouldn't be null"); Preconditions.checkNotNull(_type, "_type shouldn't be null"); Preconditions.checkNotNull(_id, "_id shouldn't be null"); Preconditions.checkNotNull(_source, "_source shouldn't be null"); Preconditions.checkNotNull(_upsertSource, "_upsertSource shouldn't be null"); Preconditions.checkState((!StringUtils.isEmpty(_index)), "_index should not be empty"); Preconditions.checkState((!StringUtils.isEmpty(_type)), "_type should not be empty"); Preconditions.checkState((!StringUtils.isEmpty(_id)), "_id should not be empty"); return getUpsertUpdateObject(_index, _type, _id, JSONUtil.getJson(_source), JSONUtil.getJson(_upsertSource)); } private static boolean isNull(Object obj) { return (obj == null); } private static boolean isNotNull(Object obj) { return !isNull(obj); } /** * Validate BulkObject based on Request type. * * If Request type * * a. is @{link BulkRequestType.INDEX} then BulkObject must has _index, * _type, _id, _source. * * b. is @{link BulkRequestType.UPDATE} then BulkObject must has _index, * _type, _id, _source. * * c. is @{link BulkRequestType.UPSERT_UPDATE} then BulkObject must has * _index, _type, _id, _source, _upsertSource. * * d. is @{link BulkRequestType.DELETE} then BulkObject must has _index, * _type, _id. * * @param type * Represents Request type, it can be INDEX, UPDATE, * UPSERT_UPDATE, DELETE. * * @param obj * @return */ private static boolean isValidBulkObject(BulkObject obj) { if (obj == null) return false; String _index = obj.get_index(); String _type = obj.get_type(); String _id = obj.get_id(); String _source = obj.get_source(); String _upsertSource = obj.get_upsertSource(); BulkRequestType type = obj.getType(); switch (type) { case INDEX: if (isNotNull(_index) && isNotNull(_type) && isNotNull(_id) && isNotNull(_source)) return true; break; case UPDATE: if (isNotNull(_index) && isNotNull(_type) && isNotNull(_id) && isNotNull(_source)) return true; break; case UPSERT_UPDATE: if (isNotNull(_index) && isNotNull(_type) && isNotNull(_id) && isNotNull(_source) && isNotNull(_upsertSource)) return true; break; case DELETE: if (isNotNull(_index) && isNotNull(_type) && isNotNull(_id)) return true; break; } return false; } /** * method takes Map of requests and execute bulk requests. Key of map * represents type of request. * * @{link BulkRequestType.INDEX} represents Index request * @{link BulkRequestType.UPDATE} represents update request * @{link BulkRequestType.UPSERT_UPDATE} represents UPSERT_UPDATE request * @{link BulkRequestType.DELETE} represents delete request * * If BulkObject is invalid, then the request is simply ignored. * * @param bulkRequest * @return */ public static BulkResponse execute(Client client, Set<BulkObject> bulkReq) { Preconditions.checkNotNull(client, "client shouldn't be null"); Preconditions.checkNotNull(bulkReq, "bulkReq shouldn't be null"); BulkRequestBuilder bulkRequest = client.prepareBulk(); for (BulkObject obj : bulkReq) { if (!isValidBulkObject(obj)) continue; String _index = obj.get_index(); String _type = obj.get_type(); String _id = obj.get_id(); String _source = obj.get_source(); String _upsertSource = obj.get_upsertSource(); BulkRequestType type = obj.getType(); switch (type) { case INDEX: bulkRequest.add(new IndexRequest(_index, _type, _id) .source(_source)); break; case UPDATE: bulkRequest.add(new UpdateRequest(_index, _type, _id) .doc(_source)); break; case UPSERT_UPDATE: bulkRequest.add(new UpdateRequest(_index, _type, _id).doc( _source).upsert(_upsertSource)); break; case DELETE: bulkRequest.add(new DeleteRequest(_index, _type, _id)); break; default: System.out.println("Invalid Request"); } } return bulkRequest.execute().actionGet(); } }
package com.self_learn.util; import static org.elasticsearch.node.NodeBuilder.nodeBuilder; import java.util.HashMap; import java.util.Map; import org.elasticsearch.client.Client; import org.elasticsearch.common.settings.ImmutableSettings; import org.elasticsearch.node.Node; import com.google.common.base.Preconditions; /** * Returns @link{Client} instance. * * @author harikrishna_gurram */ public class ClientUtil { private static Node localNode = null; private static Node localPassiveNode = null; private static Map<String, Node> activeNodes = new HashMap<>(); private static Map<String, Node> passiveNodes = new HashMap<>(); public static void closeLocalNode() { Preconditions.checkNotNull(localNode, "localNode is not initialized"); localNode.close(); } public static void closeLocalPassiveNode() { Preconditions.checkNotNull(localPassiveNode, "localPassiveNode is not initialized"); localPassiveNode.close(); } public static void closeActiveNode(String clusterName) { Preconditions .checkNotNull(clusterName, "clusterName shouldn't be null"); Preconditions.checkNotNull(activeNodes.get(clusterName), "There is no node for cluster " + clusterName); activeNodes.get(clusterName).close(); } public static void closePassiveNode(String clusterName) { Preconditions .checkNotNull(clusterName, "clusterName shouldn't be null"); Preconditions.checkNotNull(passiveNodes.get(clusterName), "There is no node for cluster " + clusterName); passiveNodes.get(clusterName).close(); } public static Client getClient() { if (localNode == null) { localNode = nodeBuilder() .settings( ImmutableSettings.settingsBuilder().put( "http.enabled", false)).client(true).node(); Client client = localNode.client(); return client; } return null; } /* Used to return passive node (Don't store any data in it) */ public static Client getPassiveClient() { if (localPassiveNode == null) { localPassiveNode = nodeBuilder() .settings( ImmutableSettings.settingsBuilder().put( "http.enabled", false)).client(true).node(); Client client = localPassiveNode.client(); return client; } return null; } public static Client getClientForCluster(String clusterName) { Preconditions .checkNotNull(clusterName, "clusterName shouldn't be null"); if (activeNodes.get(clusterName) == null) { Node node = nodeBuilder() .settings( ImmutableSettings.settingsBuilder().put( "http.enabled", false)) .clusterName(clusterName).node(); Client client = node.client(); activeNodes.put(clusterName, node); return client; } return activeNodes.get(clusterName).client(); } /* Used to return passive node (Don't store any data in it) */ public static Client getPassiveClientForCluster(String clusterName) { Preconditions .checkNotNull(clusterName, "clusterName shouldn't be null"); if (passiveNodes.get(clusterName) == null) { Node node = nodeBuilder() .settings( ImmutableSettings.settingsBuilder().put( "http.enabled", false)).client(true) .clusterName(clusterName).node(); Client client = node.client(); passiveNodes.put(clusterName, node); return client; } return passiveNodes.get(clusterName).client(); } }
package com.self_learn.util; import org.elasticsearch.action.delete.DeleteResponse; import org.elasticsearch.client.Client; import org.elasticsearch.common.lang3.StringUtils; import com.google.common.base.Preconditions; /** * Provide utility methods to delete document from Elasticsearch. * * @author harikrishna_gurram */ public class DeleteUtil { /** * Removes the docuement and return DeleteResponse. * * @param client * @param _index * @param _type * @param _id * @return DeleteResponse */ public static DeleteResponse deleteDocument(Client client, String _index, String _type, String _id) { Preconditions.checkNotNull(client, "client should not be null"); Preconditions.checkNotNull(_index, "_index should not be null"); Preconditions.checkNotNull(_type, "_type should not be null"); Preconditions.checkNotNull(_id, "_id should not be null"); Preconditions.checkState((!StringUtils.isEmpty(_index)), "_index should not be empty"); Preconditions.checkState((!StringUtils.isEmpty(_type)), "_type should not be empty"); Preconditions.checkState((!StringUtils.isEmpty(_id)), "_id should not be empty"); DeleteResponse response = client.prepareDelete(_index, _type, _id) .execute().actionGet(); return response; } }
package com.self_learn.util; import java.util.Set; import org.elasticsearch.action.admin.cluster.state.ClusterStateResponse; import org.elasticsearch.action.admin.indices.stats.IndicesStatsRequest; import org.elasticsearch.action.index.IndexResponse; import org.elasticsearch.client.Client; import org.elasticsearch.cluster.metadata.AliasMetaData; import org.elasticsearch.cluster.metadata.MappingMetaData; import org.elasticsearch.common.collect.ImmutableOpenMap; import org.elasticsearch.common.hppc.ObjectLookupContainer; import org.elasticsearch.common.lang3.StringUtils; import com.google.common.base.Preconditions; /** * Provides utility methods to store data into Elasticsearch. * * @author harikrishna_gurram */ public class IndexUtil { /** * Index given document. * * @param client * : Client used to index data * @param _index * : Document is stored in this index * @param _type * : Document stored in this type * @param _id * : Specifies _id of the document * @param document * : Represents body of the document * @return {@link IndexResponse} */ public static IndexResponse indexData(Client client, String _index, String _type, String _id, String document) { Preconditions.checkNotNull(client, "client should not be null"); Preconditions.checkNotNull(_index, "_index should not be null"); Preconditions.checkNotNull(_type, "_type should not be null"); Preconditions.checkNotNull(_id, "_id should not be null"); Preconditions.checkNotNull(document, "data should not be null"); Preconditions.checkState((!StringUtils.isEmpty(_index)), "_index should not be empty"); Preconditions.checkState((!StringUtils.isEmpty(_type)), "_type should not be empty"); Preconditions.checkState((!StringUtils.isEmpty(_id)), "_id should not be empty"); IndexResponse response = client.prepareIndex(_index, _type, _id) .setSource(document).execute().actionGet(); return response; } /** * Index given object. * * @param client * : Client used to index data * @param _index * : Document is stored in this index * @param _type * : Document stored in this type * @param _id * : Specifies _id of the document * @param obj * : Object to index * @return {@link IndexResponse} */ public static IndexResponse indexData(Client client, String _index, String _type, String _id, Object obj) { Preconditions.checkNotNull(client, "client should not be null"); Preconditions.checkNotNull(_index, "_index should not be null"); Preconditions.checkNotNull(_type, "_type should not be null"); Preconditions.checkNotNull(_id, "_id should not be null"); Preconditions.checkNotNull(obj, "data should not be null"); Preconditions.checkState((!StringUtils.isEmpty(_index)), "_index should not be empty"); Preconditions.checkState((!StringUtils.isEmpty(_type)), "_type should not be empty"); Preconditions.checkState((!StringUtils.isEmpty(_id)), "_id should not be empty"); return indexData(client, _index, _type, _id, JSONUtil.getJson(obj)); } /** * Return all aliases of indices * * @param client * @return */ public static ImmutableOpenMap<String, ImmutableOpenMap<String, AliasMetaData>> getAllIndicesAlases( Client client) { Preconditions.checkNotNull(client, "Client shouldn't be null"); return client.admin().cluster().prepareState().execute().actionGet() .getState().getMetaData().aliases(); } /** * Return all indices from cluster. * * @param client * @return */ public static Set<String> getAllIndices(Client client) { Preconditions.checkNotNull(client, "client shouldn't be null"); return client.admin().indices().stats(new IndicesStatsRequest()) .actionGet().getIndices().keySet(); } /** * Return all mappings of given index * * @param client * @param index * @return */ public static ImmutableOpenMap<String, MappingMetaData> getMappingsOfIndex( Client client, String index) { Preconditions.checkNotNull(client, "client shouldn't be null"); Preconditions.checkNotNull(index, "index shouldn't be null"); Preconditions.checkState((!StringUtils.isEmpty(index)), "index should not be empty"); ClusterStateResponse clusterStateResponse = client.admin().cluster() .prepareState().execute().actionGet(); return clusterStateResponse.getState().getMetaData().index(index) .getMappings(); } /** * Get all types in given index * * @param client * @param index * @return */ public static ObjectLookupContainer<String> getAllTypesFromIndex( Client client, String index) { Preconditions.checkNotNull(client, "client shouldn't be null"); Preconditions.checkNotNull(index, "index shouldn't be null"); Preconditions.checkState((!StringUtils.isEmpty(index)), "index should not be empty"); return getMappingsOfIndex(client, index).keys(); } }
package com.self_learn.util; import org.apache.commons.validator.routines.InetAddressValidator; import org.elasticsearch.common.lang3.StringUtils; import com.google.common.base.Preconditions; /** * Validate IPaddresses, ports * * @author harikrishna_gurram */ public class IPUtil { private static InetAddressValidator inetAddressValidator = InetAddressValidator .getInstance(); /** * @param ipAddress * @return true if ip address is valid, else false */ public static boolean isValidIPAddress(String ipAddress) { Preconditions.checkNotNull(ipAddress, "IP address should not be null"); Preconditions.checkState((!StringUtils.isEmpty(ipAddress)), "ipAddress should not be empty"); return inetAddressValidator.isValid(ipAddress); } /** * @param port * : Port number * @return true if port number is valid, else false */ public static boolean isValidPort(int port) { if (port > 0 && port < 65536) return true; return false; } /** * @param hostNames * @return true if all the elements of array represents valid hosnames, else * false. */ public static boolean isValidHosts(String[] hostNames) { Preconditions.checkNotNull(hostNames, "Host names shouldn't be empty"); for (String hostName : hostNames) { if (!isValidIPAddress(hostName)) { return false; } } return true; } /** * * @param ports * @return true if all the elements of array represents valid ports, else * false. */ public static boolean isValidPorts(Integer[] ports) { Preconditions.checkNotNull(ports, "ports shouldn't be empty"); for (int port : ports) { if (!isValidPort(port)) { return false; } } return true; } }
package com.self_learn.util; import org.elasticsearch.common.base.Preconditions; import com.google.gson.Gson; import com.google.gson.GsonBuilder; /** * Convert object to json string. * * @author harikrishna_gurram */ public class JSONUtil { private static Gson gson = new Gson(); private static Gson prettyGson = new GsonBuilder().setPrettyPrinting() .create(); /** * @param obj * @return json string of this object. */ public static String getJson(Object obj) { Preconditions.checkNotNull(obj, "obj shouldn't be null"); return gson.toJson(obj); } /** * @param obj * @return json string of this object (Pretty json). */ public static String getPrettyJson(Object obj) { Preconditions.checkNotNull(obj, "obj shouldn't be null"); return prettyGson.toJson(obj); } /** * Convert given json string to object. * * @param json * @param obj * @return an object by populating properties with json data. */ public static <T> T getObject(String json, Class<T> clazz) { Preconditions.checkNotNull(json, "json data shouldn't be null"); Preconditions.checkNotNull(clazz, "clazz shouldn't be null"); return gson.fromJson(json, clazz); } }
package com.self_learn.util; import org.elasticsearch.action.bulk.BulkResponse; import org.elasticsearch.action.get.GetResponse; import com.google.common.base.Preconditions; /** * Utility class to return response in string format. * * @author harikrishna_gurram */ public class ResponseUtil { /** * Returns source of the result as string. * * @param response * @return */ public static String getSource(GetResponse response, boolean pretty) { Preconditions.checkNotNull(response, "response shouldn't be null"); return response.getSourceAsString(); } /** * @param response * @return string representation of {@link BulkResponse} */ public static String getResponseInfo(Object response) { return response.toString(); } }
package com.self_learn.util; import org.elasticsearch.action.count.CountResponse; import org.elasticsearch.action.get.GetResponse; import org.elasticsearch.action.search.SearchResponse; import org.elasticsearch.client.Client; import org.elasticsearch.common.lang3.StringUtils; import org.elasticsearch.index.query.QueryBuilder; import com.google.common.base.Preconditions; /** * Provide various utility methods to query Elasticsearch. * * @author harikrishna_gurram */ public class SearchUtil { /** * Returns the document by id (Takes _index, _type, _id as input). * * @param client * @param _index * @param _type * @param _id * @return the document by id */ public static GetResponse getDocumentById(Client client, String _index, String _type, String _id) { Preconditions.checkNotNull(client, "client should not be null"); Preconditions.checkNotNull(_index, "_index should not be null"); Preconditions.checkNotNull(_type, "_type should not be null"); Preconditions.checkNotNull(_id, "_id should not be null"); Preconditions.checkState((!StringUtils.isEmpty(_index)), "_index should not be empty"); Preconditions.checkState((!StringUtils.isEmpty(_type)), "_type should not be empty"); Preconditions.checkState((!StringUtils.isEmpty(_id)), "_id should not be empty"); GetResponse response = client.prepareGet(_index, _type, _id).execute() .actionGet(); return response; } /** * Return all the documents from a cluster. * * @param client * @return */ public static SearchResponse getAllDocuemnts(Client client) { Preconditions.checkNotNull(client, "client shouldn't be null"); return client.prepareSearch().execute().actionGet(); } /** * Return first n documents from cluster * * @param client * @param n * must > 0 * @return first n documents from cluster */ public static SearchResponse getFirstNDocuments(Client client, int n) { Preconditions.checkNotNull(client, "client shouldn't be null"); Preconditions.checkState((n > 0), "n must greater than 0"); return client.prepareSearch().setSize(n).execute().actionGet(); } /** * Return documents from index from to from+size * * @param client * @param from * starting index * @param size * Number of documents to return * @return documents from index from to from+size */ public static SearchResponse getDocuments(Client client, int from, int size) { Preconditions.checkNotNull(client, "client shouldn't be null"); Preconditions.checkState((from > 0), "from must greater than 0"); Preconditions.checkState((size > 0), "size must greater than 0"); return client.prepareSearch().setSize(size).setFrom(from).execute() .actionGet(); } /** * Return all documents from given indices. * * @param client * @param indices * @return */ public static SearchResponse getAllDocuments(Client client, String... indices) { Preconditions.checkNotNull(client, "client shouldn't be null"); Preconditions.checkNotNull(indices, "indeices shouldn't be null"); return client.prepareSearch(indices).execute().actionGet(); } /** * Return first n documents from given indices * * @param client * @param n * @param indices * @return first n documents from given indices */ public static SearchResponse getFirstNDocuments(Client client, int n, String... indices) { Preconditions.checkNotNull(client, "client shouldn't be null"); Preconditions.checkState((n > 0), "n must greater than 0"); Preconditions.checkNotNull(indices, "indices shouldn't be null"); return client.prepareSearch(indices).setSize(n).execute().actionGet(); } /** * Return documents from index from to from+size * * @param client * @param from * starting index * @param size * Number of documents to return * @param indices * @return */ public static SearchResponse getDocuments(Client client, int from, int size, String... indices) { Preconditions.checkNotNull(client, "client shouldn't be null"); Preconditions.checkState((from > 0), "from must greater than 0"); Preconditions.checkState((size > 0), "size must greater than 0"); Preconditions.checkNotNull(indices, "indices shouldn't be null"); return client.prepareSearch(indices).setSize(size).setFrom(from) .execute().actionGet(); } /** * Return all documents from given indexes and types. * * @param client * @param indices * @param types * @return @{link SearchResponse} */ public static SearchResponse getAllDocuments(Client client, String[] indices, String[] types) { Preconditions.checkNotNull(client, "client shouldn't be null"); Preconditions.checkNotNull(indices, "indeices shouldn't be null"); Preconditions.checkNotNull(types, "types shouldn't be null"); return client.prepareSearch(indices).setTypes(types).execute() .actionGet(); } /** * Return all documents from given index and type. * * @param client * @param _index * @param _type * @return @{link SearchResponse} */ public static SearchResponse getAllDocuments(Client client, String _index, String _type) { Preconditions.checkNotNull(client, "client shouldn't be null"); Preconditions.checkNotNull(_index, "indeices shouldn't be null"); Preconditions.checkNotNull(_type, "types shouldn't be null"); Preconditions.checkState((!StringUtils.isEmpty(_index)), "_index should not be empty"); Preconditions.checkState((!StringUtils.isEmpty(_type)), "_type should not be empty"); return client.prepareSearch(_index).setTypes(_type).execute() .actionGet(); } /** * Return first n documents from given indices and types. * * @param client * @param n * @param indices * @param types * @return first n documents from given indices and types. */ public static SearchResponse getFirstNDocuments(Client client, int n, String[] indices, String[] types) { Preconditions.checkNotNull(client, "client shouldn't be null"); Preconditions.checkState((n > 0), "n must greater than 0"); Preconditions.checkNotNull(indices, "indeices shouldn't be null"); Preconditions.checkNotNull(types, "types shouldn't be null"); return client.prepareSearch(indices).setTypes(types).setSize(n) .execute().actionGet(); } /** * Return first n documents from given index and type. * * @param client * @param n * @param _index * @param _type * @return first n documents from given index and type. */ public static SearchResponse getFirstNDocuments(Client client, int n, String _index, String _type) { Preconditions.checkNotNull(client, "client shouldn't be null"); Preconditions.checkState((n > 0), "n must greater than 0"); Preconditions.checkNotNull(_index, "index shouldn't be null"); Preconditions.checkNotNull(_type, "type shouldn't be null"); Preconditions.checkState((!StringUtils.isEmpty(_index)), "_index should not be empty"); Preconditions.checkState((!StringUtils.isEmpty(_type)), "_type should not be empty"); return client.prepareSearch(_index).setTypes(_type).setSize(n) .execute().actionGet(); } /** * Return documents from index 'from' to 'from+size'. * * @param client * @param from * starting index * @param size * Number of documents to return * @param indices * @param types * @return */ public static SearchResponse getDocuments(Client client, int from, int size, String[] indices, String[] types) { Preconditions.checkNotNull(client, "client shouldn't be null"); Preconditions.checkState((from > 0), "from must greater than 0"); Preconditions.checkState((size > 0), "size must greater than 0"); Preconditions.checkNotNull(indices, "indeices shouldn't be null"); Preconditions.checkNotNull(types, "types shouldn't be null"); return client.prepareSearch(indices).setTypes(types).setSize(size) .setFrom(from).execute().actionGet(); } /** * Return documents from index 'from' to 'from+size'. * * @param client * @param from * starting index * @param size * Number of documents to return * @param _index * @param _type * @return */ public static SearchResponse getDocuments(Client client, int from, int size, String _index, String _type) { Preconditions.checkNotNull(client, "client shouldn't be null"); Preconditions.checkState((from > 0), "from must greater than 0"); Preconditions.checkState((size > 0), "size must greater than 0"); Preconditions.checkNotNull(_index, "index shouldn't be null"); Preconditions.checkNotNull(_type, "type shouldn't be null"); Preconditions.checkState((!StringUtils.isEmpty(_index)), "_index should not be empty"); Preconditions.checkState((!StringUtils.isEmpty(_type)), "_type should not be empty"); return client.prepareSearch(_index).setTypes(_type).setSize(size) .setFrom(from).execute().actionGet(); } /** * Return number of matches for given query * * @param client * @param builder * @param indices * @return */ public static long getNumberOfMatches(Client client, QueryBuilder builder, String... indices) { Preconditions.checkNotNull(client, "client shouldn't be null"); Preconditions.checkNotNull(builder, "builder shouldn't be null"); Preconditions.checkNotNull(indices, "indices shouldn't be null"); CountResponse response = client.prepareCount(indices).setQuery(builder) .execute().actionGet(); return response.getCount(); } /** * Get documents that matches to give query. * * @param client * @param builder * @param indices * @return */ public static SearchResponse getDocuments(Client client, QueryBuilder builder, String... indices) { Preconditions.checkNotNull(client, "Client shouldn't be null"); Preconditions.checkNotNull(builder, "builder shouldn't be null"); Preconditions.checkNotNull(indices, "indices shouldn't be null"); return client.prepareSearch(indices).setQuery(builder).execute() .actionGet(); } /** * Return first n documents that matches to given query. * * @param client * @param n * Number of documents to return * @param builder * specifies query * @param indices * indices to query * @return */ public static SearchResponse getFirstNDocuments(Client client, int n, QueryBuilder builder, String... indices) { Preconditions.checkNotNull(client, "client shouldn't be null"); Preconditions.checkState((n > 0), "n must greater than 0"); Preconditions.checkNotNull(builder, "builder shouldn't be null"); Preconditions.checkNotNull(indices, "indices shouldn't be null"); return client.prepareSearch(indices).setQuery(builder).setSize(n) .execute().actionGet(); } /** * Return documents from index 'from' to 'from+size' * * @param client * @param from * starting index * @param size * number of documents to return * @param builder * specifies query * @param indices * indices to query * @return documents from index 'from' to 'from+size' */ public static SearchResponse getDocuments(Client client, int from, int size, QueryBuilder builder, String... indices) { Preconditions.checkNotNull(client, "client shouldn't be null"); Preconditions.checkState((from > 0), "from must greater than 0"); Preconditions.checkState((size > 0), "size must greater than 0"); Preconditions.checkNotNull(builder, "builder shouldn't be null"); Preconditions.checkNotNull(indices, "indices shouldn't be null"); return client.prepareSearch(indices).setQuery(builder).setSize(size) .setFrom(from).execute().actionGet(); } /** * Return documents that matches to given query. * * @param client * @param builder * Specifies query * @param indices * indices to query * @param types * types to query * @return */ public static SearchResponse getDocuments(Client client, QueryBuilder builder, String[] indices, String[] types) { Preconditions.checkNotNull(client, "client shouldn't be null"); Preconditions.checkNotNull(builder, "builder shouldn't be null"); Preconditions.checkNotNull(indices, "indices shouldn't be null"); Preconditions.checkNotNull(types, "types shouldn't be null"); return client.prepareSearch(indices).setTypes(types).setQuery(builder) .execute().actionGet(); } /** * Return documents that matches to given query. * * @param client * @param builder * Specifies query * @param _index * index to query * @param _type * type to query * @return */ public static SearchResponse getDocuments(Client client, QueryBuilder builder, String _index, String _type) { Preconditions.checkNotNull(client, "client shouldn't be null"); Preconditions.checkNotNull(builder, "builder shouldn't be null"); Preconditions.checkNotNull(_index, "index shouldn't be null"); Preconditions.checkNotNull(_type, "type shouldn't be null"); Preconditions.checkState((!StringUtils.isEmpty(_index)), "_index should not be empty"); Preconditions.checkState((!StringUtils.isEmpty(_type)), "_type should not be empty"); return client.prepareSearch(_index).setTypes(_type).setQuery(builder) .execute().actionGet(); } /** * Return first n documents that matches to given query. * * @param client * @param n * number of documents to return * @param builder * specifies query * @param indices * indices to query * @param types * types to query * @return first n documents that matches to given query. */ public static SearchResponse getFirstNDocuments(Client client, int n, QueryBuilder builder, String[] indices, String[] types) { Preconditions.checkNotNull(client, "client shouldn't be null"); Preconditions.checkState((n > 0), "n must greater than 0"); Preconditions.checkNotNull(builder, "builder shouldn't be null"); Preconditions.checkNotNull(indices, "indices shouldn't be null"); Preconditions.checkNotNull(types, "types shouldn't be null"); return client.prepareSearch(indices).setTypes(types).setSize(n) .setQuery(builder).execute().actionGet(); } /** * Return first n documents that matches to given query. * * @param client * @param n * number of documents to return * @param builder * specifies query * @param index * index to query * @param type * type to query * @return first n documents that matches to given query. */ public static SearchResponse getFirstNDocuments(Client client, int n, QueryBuilder builder, String index, String[] type) { Preconditions.checkNotNull(client, "client shouldn't be null"); Preconditions.checkState((n > 0), "n must greater than 0"); Preconditions.checkNotNull(builder, "builder shouldn't be null"); Preconditions.checkNotNull(index, "index shouldn't be null"); Preconditions.checkNotNull(type, "types shouldn't be null"); return client.prepareSearch(index).setTypes(type).setSize(n) .setQuery(builder).execute().actionGet(); } /** * Return documents from index 'from' to 'from+size' * * @param client * @param from * starting index of the document * @param size * Number of documents to return * @param builder * specifies the query * @param indices * Indices to query * @param types * types to query * @return */ public static SearchResponse getDocuments(Client client, int from, int size, QueryBuilder builder, String[] indices, String[] types) { Preconditions.checkNotNull(client, "client shouldn't be null"); Preconditions.checkState((from > 0), "from must greater than 0"); Preconditions.checkState((size > 0), "size must greater than 0"); Preconditions.checkNotNull(builder, "builder shouldn't be null"); Preconditions.checkNotNull(indices, "indices shouldn't be null"); Preconditions.checkNotNull(types, "types shouldn't be null"); return client.prepareSearch(indices).setTypes(types).setSize(size) .setFrom(from).setQuery(builder).execute().actionGet(); } /** * Return documents from index 'from' to 'from+size' * * @param client * @param from * starting index of the document * @param size * Number of documents to return * @param builder * specifies the query * @param _index * index to query * @param _type * type to query * @return */ public static SearchResponse getDocuments(Client client, int from, int size, QueryBuilder builder, String _index, String _type) { Preconditions.checkNotNull(client, "client shouldn't be null"); Preconditions.checkState((from > 0), "from must greater than 0"); Preconditions.checkState((size > 0), "size must greater than 0"); Preconditions.checkNotNull(builder, "builder shouldn't be null"); Preconditions.checkNotNull(_index, "index shouldn't be null"); Preconditions.checkNotNull(_type, "types shouldn't be null"); Preconditions.checkState((!StringUtils.isEmpty(_index)), "index should not be empty"); Preconditions.checkState((!StringUtils.isEmpty(_type)), "type should not be empty"); return client.prepareSearch(_index).setTypes(_type).setSize(size) .setFrom(from).setQuery(builder).execute().actionGet(); } }
package com.self_learn.util; import static com.self_learn.util.IPUtil.isValidHosts; import static com.self_learn.util.IPUtil.isValidPorts; import java.net.InetAddress; import java.net.UnknownHostException; import java.util.HashMap; import java.util.HashSet; import java.util.Map; import java.util.Set; import org.elasticsearch.client.Client; import org.elasticsearch.client.transport.TransportClient; import org.elasticsearch.common.settings.ImmutableSettings; import org.elasticsearch.common.settings.Settings; import org.elasticsearch.common.transport.InetSocketTransportAddress; import com.google.common.base.Preconditions; public class TransportClientUtil { private static Map<Map<String, Integer>, Client> localMap = new HashMap<>(); /** * Take machine name and port addresses as map and return transport client. * Key is host name, value is port number * * @throws UnknownHostException */ public static Client getTransportClient(String clusterName, Map<String, Integer> map) throws UnknownHostException { Preconditions.checkNotNull(clusterName, "clusterName shouldn't be empty"); Preconditions.checkNotNull(map, "Map shouldn't be empty"); if (localMap.containsKey(map)) return localMap.get(map); Preconditions.checkState(isValidHostPorts(map), "Map contains invalid host (or) port"); Settings settings = ImmutableSettings.settingsBuilder() .put("cluster.name", clusterName) .put("client.transport.sniff", true).build(); TransportClient client = new TransportClient(settings); InetSocketTransportAddress addresses[] = getInetSocketTransportAddresses(map); client.addTransportAddresses(addresses); localMap.put(map, client); return client; } /** * @param map * @return true, if all the entries in map are valid host, ports. Else * false. */ private static boolean isValidHostPorts(Map<String, Integer> map) { Set<String> hostNames = map.keySet(); Set<Integer> ports = new HashSet<>(map.values()); if (!isValidHosts(hostNames.toArray(new String[hostNames.size()]))) return false; if (!isValidPorts(ports.toArray(new Integer[ports.size()]))) return false; return true; } private static InetSocketTransportAddress[] getInetSocketTransportAddresses( Map<String, Integer> map) throws UnknownHostException { InetSocketTransportAddress addresses[] = new InetSocketTransportAddress[map .size()]; int count = 0; Set<String> keys = map.keySet(); for (String key : keys) { InetAddress addr = InetAddress.getByName(key); InetSocketTransportAddress address = new InetSocketTransportAddress( addr, map.get(key)); addresses[count] = address; } return addresses; } /** * Get transport client for localhost. * * @param clusterName * @param port * @return * @throws UnknownHostException */ public static Client getLocalTransportClient(String clusterName, int port) throws UnknownHostException { Settings settings = ImmutableSettings.settingsBuilder() .put("cluster.name", clusterName) .put("client.transport.sniff", true).build(); TransportClient client = new TransportClient(settings); InetAddress addr = InetAddress.getByName("127.0.0.1"); InetSocketTransportAddress address = new InetSocketTransportAddress( addr, port); client.addTransportAddress(address); return client; } }
package com.self_learn.util; import java.io.IOException; import java.util.Map; import java.util.concurrent.ExecutionException; import org.elasticsearch.action.update.UpdateRequest; import org.elasticsearch.action.update.UpdateResponse; import org.elasticsearch.client.Client; import org.elasticsearch.common.lang3.StringUtils; import com.google.common.base.Preconditions; /** * Provides various utility methods to update a document. * * @author harikrishna_gurram */ public class UpdateUtil { /** * Updates document with given fields (Fields are given as map) * * @param client * @param _index * @param _type * @param _id * @param data * @return {@link UpdateResponse} * @throws IOException * @throws InterruptedException * @throws ExecutionException */ public static UpdateResponse updateDocument(Client client, String _index, String _type, String _id, Map<String, Object> data) throws IOException, InterruptedException, ExecutionException { Preconditions.checkNotNull(data, "data should not be null"); return updateDocument(client, _index, _type, _id, JSONUtil.getJson(data)); } public static UpdateResponse updateDocument(Client client, String _index, String _type, String _id, String data) throws InterruptedException, ExecutionException { Preconditions.checkNotNull(client, "client should not be null"); Preconditions.checkNotNull(_index, "_index should not be null"); Preconditions.checkNotNull(_type, "_type should not be null"); Preconditions.checkNotNull(_id, "_id should not be null"); Preconditions.checkNotNull(data, "data should not be null"); Preconditions.checkState((!StringUtils.isEmpty(_index)), "_index should not be empty"); Preconditions.checkState((!StringUtils.isEmpty(_type)), "_type should not be empty"); Preconditions.checkState((!StringUtils.isEmpty(_id)), "_id should not be empty"); UpdateRequest updateRequest = new UpdateRequest(_index, _type, _id); updateRequest.doc(data); UpdateResponse resposne = client.update(updateRequest).get(); return resposne; } /** * If the document does not already exist, the contents of the upsertMap * will be inserted as a new document. * * @param client * @param _index * @param _type * @param _id * @param _source * @param _upsertSource * @return * @throws IOException * @throws ExecutionException * @throws InterruptedException */ public static UpdateResponse upsertUpdate(Client client, String _index, String _type, String _id, Map<String, Object> _source, Map<String, Object> _upsertSource) throws IOException, InterruptedException, ExecutionException { Preconditions.checkNotNull(_source, "data should not be null"); Preconditions.checkNotNull(_upsertSource, "upsertData should not be null"); return upsertUpdate(client, _index, _type, _id, JSONUtil.getJson(_source), JSONUtil.getJson(_upsertSource)); } public static UpdateResponse upsertUpdate(Client client, String _index, String _type, String _id, String _source, String _upsertSource) throws IOException, InterruptedException, ExecutionException { Preconditions.checkNotNull(client, "client should not be null"); Preconditions.checkNotNull(_index, "_index should not be null"); Preconditions.checkNotNull(_type, "_type should not be null"); Preconditions.checkNotNull(_id, "_id should not be null"); Preconditions.checkNotNull(_source, "data should not be null"); Preconditions.checkNotNull(_upsertSource, "upsertData should not be null"); Preconditions.checkState((!StringUtils.isEmpty(_index)), "_index should not be empty"); Preconditions.checkState((!StringUtils.isEmpty(_type)), "_type should not be empty"); Preconditions.checkState((!StringUtils.isEmpty(_id)), "_id should not be empty"); UpdateRequest updateRequest = new UpdateRequest(_index, _type, _id); updateRequest.doc(_source); updateRequest.upsert(_upsertSource); UpdateResponse response = client.update(updateRequest).get(); return response; } }
No comments:
Post a Comment