Using the native protocol

ElasticSearch provides a native protocol, used mainly for low-level communication between nodes, but very useful for fast importing of huge data blocks. This protocol is available only for Java Virtual Machine (JVM) languages and commonly is used in Java, Groovy, and Scala.

Getting ready

You need a working instance of the ElasticSearch cluster; the standard port number for native protocol is 9300.

How to do it...

The following are the steps required to use the native protocol in a Java environment (we'll discuss this in depth in Chapter 10, Java Integration):

1. Before starting, we must be sure that Maven loads the Elasticsearch.jar file by adding the following code to the pom.xml file:

   <dependency>
     <groupId>org.elasticsearch</groupId>
     <artifactId>elasticsearch</artifactId>
     <version>1.4.1</version>
   </dependency>

2. Depending on the Elasticsearch.jar file, creating a Java client is quite easy:

   import org.elasticsearch.common.settings.ImmutableSettings;
   import org.elasticsearch.common.settings.Settings;
   import org.elasticsearch.client.Client;
   import org.elasticsearch.client.transport.TransportClient;
   …
   Settings settings = ImmutableSettings.settingsBuilder()
   .put("client.transport.sniff", true).build();
     // we define a new settings
     // using sniff transport allows to autodetect other nodes
   Client client = new TransportClient(settings)
     .addTransportAddress(new InetSocketTransportAddress("127.0.0.1", 9300));
     // a client is created with the settings

How it works...

To initialize a native client, a settings object is required, which contains some configuration parameters. The most important ones are:

• cluster.name: This is the name of the cluster
• client.transport.sniff: This allows you to sniff out the rest of the cluster and add them into its list of machines to use

With the settings object, it's possible to initialize a new client by giving an IP address and port a number (default 9300).

There's more...

The native protocol is the internal one used in ElasticSearch. It's the fastest protocol that is available to communicate with ElasticSearch.

The native protocol is an optimized binary and works only for JVM languages; to use this protocol, you need to include the elasticsearch.jar in your JVM project. Because it depends on ElasticSearch implementation, it must be the same version of ElasticSearch cluster.

For this reason, every time you update ElasticSearch, you need to update the elasticsearch.jar file on which it depends and if there are internal API changes, you need to update your code.

To use this protocol, you need to study the internals of ElasticSearch, so it's not as easy to use as HTTP and Thrift protocol.

Native protocol is useful for massive data import. But as ElasticSearch is mainly thought as a REST HTTP server to communicate with, it lacks support for everything that is not standard in the ElasticSearch core, such as the plugin's entry points. So using this protocol, you are unable to call entry points made by external plugins.

Note

The native protocol seems the most easy to integrate in a Java/JVM project. However, due to its nature that follows the fast release cycles of ElasticSearch, it changes very often. Also, for minor release upgrades, your code is more likely to be broken. Thus, ElasticSearch developers wisely tries to fix them in the latest releases.

See also

• The native protocol is the most used in the Java world and it will be deeply discussed in Chapter 10, Java Integration and Chapter 12, Plugin Development
• Further details on ElasticSearch Java API are available on the ElasticSearch website at http://www.elasticsearch.org/guide/en/elasticsearch/client/java-api/current/index.html